28 
  29 
  30 def _find_task_run_by_id(task_run_id: str) -> TaskRun | None:
  31     """Search all projects and tasks for a task run with the given ID."""
! 32     project_paths = Config.shared().projects or []
! 33     for project_path in project_paths:
! 34         try:
! 35             project = Project.load_from_file(project_path)
! 36         except Exception:
! 37             continue
! 38         for task in project.tasks():
! 39             run = TaskRun.from_id_and_parent_path(task_run_id, task.path)
! 40             if run is not None:
! 41                 return run
! 42     return None
  43 
  44 
  45 def _execute_client_tool(tool_name: str, arguments: dict[str, Any]) -> str:
  46     """Execute a client-side tool and return the result as a string."""

  52             run = _find_task_run_by_id(task_run_id)
  53             if run is None:
  54                 return json.dumps({"error": f"Task run not found: {task_run_id}"})
  55             return run.model_dump_json(indent=2)
! 56         except Exception as e:
! 57             return json.dumps({"error": f"Failed to read task run: {e}"})
  58     return json.dumps({"error": f"Unknown client tool: {tool_name}"})
  59 
  60 
  61 def _parse_sse_events(

  79                         and event.get("type") == "client-tool-call"
  80                     ):
  81                         client_tool_event = event
  82                         continue
! 83                 except (json.JSONDecodeError, TypeError):
! 84                     pass
  85         lines_to_forward.append(line)
  86 
  87     return lines_to_forward, client_tool_event

  120                                     detail = (
  121                                         json.loads(error_body).get("message", detail)
  122                                         or detail
  123                                     )
! 124                                 except json.JSONDecodeError:
! 125                                     pass
  126                             yield f"data: {json.dumps({'type': 'error', 'message': detail})}\n\n".encode()
  127                             return
  128 
  129                         try:

  133                                     client_tool_event = tool_event
  134                                 forward_bytes = b"\n".join(lines)
  135                                 if forward_bytes.strip():
  136                                     yield forward_bytes + b"\n"
! 137                         except httpx.RemoteProtocolError:
! 138                             if client_tool_event is not None:
! 139                                 logger.debug(
  140                                     "Connection closed after client tool call event (expected)"
  141                                 )
  142                             else:
! 143                                 raise
  144 
  145                 if client_tool_event is None:
  146                     return

  274         self._prior_trace = prior_trace
  275 
  276     def _is_tool_continuation(self) -> bool:
  277         if not self._prior_trace:
! 278             return False
  279         last = self._prior_trace[-1]
  280         return isinstance(last, dict) and last.get("role") == "tool"
  281 
  282     def initial_messages(self) -> list[ChatCompletionMessageIncludingLiteLLM]:

  692     @property
  693     def task_run(self) -> TaskRun:
  694         if self._task_run is None:
  695             if self.client_tool_pending:
! 696                 raise RuntimeError(
  697                     "No task_run available: stream ended with a client tool call. "
  698                     "Check .client_tool_pending before accessing .task_run"
  699                 )
  700             raise RuntimeError(

  732                     elif isinstance(event, ToolCallEvent):
  733                         last_event_was_tool_call = True
  734                         for ai_event in converter.convert_tool_event(event):
  735                             yield ai_event
! 736             except ClientToolCallRequired as e:
! 737                 self.client_tool_pending = True
! 738                 yield AiSdkStreamEvent(
  739                     AiSdkEventType.CLIENT_TOOL_CALL,
  740                     {
  741                         "toolCallId": e.tool_call_id,
  742                         "toolName": e.tool_name,

  742                         "toolName": e.tool_name,
  743                         "input": e.arguments,
  744                     },
  745                 )
! 746                 for ai_event in converter.finalize():
! 747                     yield ai_event
! 748                 yield AiSdkStreamEvent(AiSdkEventType.FINISH_STEP)
! 749                 return
  750 
  751             for ai_event in converter.finalize():
  752                 yield ai_event

  698 
  699                 try:
  700                     result = await t.run(c, **args)
  701                 except ClientToolCallRequired as e:
! 702                     e.tool_call_id = tc_id
! 703                     raise
  704                 return ChatCompletionToolMessageParamWrapper(
  705                     role="tool",
  706                     tool_call_id=tc_id,
  707                     content=result.output,

  85     # Client tools: client_tool::<tool_name>
  86     if id.startswith(CLIENT_TOOL_ID_PREFIX):
  87         tool_name = client_tool_name_from_id(id)
  88         if not tool_name:
! 89             raise ValueError(
  90                 f"Invalid client tool ID: {id}. Expected format: 'client_tool::<tool_name>'."
  91             )
  92         return id

  53     async def name(self) -> str:
  54         return self._name
  55 
  56     async def description(self) -> str:
! 57         return self._description
  58 
  59     async def toolcall_definition(self) -> ToolCallDefinition:
  60         return {
  61             "type": "function",